﻿using System;
using System.ComponentModel;

namespace HalconDotNet
{
	/// <summary>Represents an instance of an XLD extended parallel object(-array).</summary>
	// Token: 0x02000075 RID: 117
	[Serializable]
	public class HXLDExtPara : HXLD
	{
		/// <summary>Create an uninitialized iconic object</summary>
		// Token: 0x06001C8C RID: 7308 RVA: 0x000ABEF9 File Offset: 0x000AA0F9
		public HXLDExtPara() : base(HObjectBase.UNDEF, false)
		{
		}

		// Token: 0x06001C8D RID: 7309 RVA: 0x000B0F4E File Offset: 0x000AF14E
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLDExtPara(IntPtr key) : this(key, true)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001C8E RID: 7310 RVA: 0x000B0F64 File Offset: 0x000AF164
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLDExtPara(IntPtr key, bool copy) : base(key, copy)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001C8F RID: 7311 RVA: 0x000B0F7A File Offset: 0x000AF17A
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLDExtPara(HObject obj) : base(obj)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001C90 RID: 7312 RVA: 0x000B0F8F File Offset: 0x000AF18F
		private void AssertObjectClass()
		{
			HalconAPI.AssertObjectClass(this.key, "xld_ext_para");
		}

		/// <summary>Returns the iconic object(s) at the specified index</summary>
		// Token: 0x17000067 RID: 103
		public HXLDExtPara this[HTuple index]
		{
			get
			{
				return this.SelectObj(index);
			}
		}

		// Token: 0x06001C92 RID: 7314 RVA: 0x000B0FAA File Offset: 0x000AF1AA
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static int LoadNew(IntPtr proc, int parIndex, int err, out HXLDExtPara obj)
		{
			obj = new HXLDExtPara(HObjectBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		/// <summary>
		///   Join modified XLD parallels lying on the same polygon.
		///   Instance represents: Extended XLD parallels.
		/// </summary>
		/// <returns>Maximally extended parallels.</returns>
		// Token: 0x06001C93 RID: 7315 RVA: 0x000B0FC4 File Offset: 0x000AF1C4
		public HXLDPoly MaxParallelsXld()
		{
			IntPtr proc = HalconAPI.PreCall(38);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPoly result;
			num = HXLDPoly.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the difference of two object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objectsSub">Object tuple 2.</param>
		/// <returns>Objects from Objects that are not part of ObjectsSub.</returns>
		// Token: 0x06001C94 RID: 7316 RVA: 0x000B100C File Offset: 0x000AF20C
		public HXLDExtPara ObjDiff(HXLDExtPara objectsSub)
		{
			IntPtr proc = HalconAPI.PreCall(573);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsSub);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsSub);
			return result;
		}

		/// <summary>
		///   Copy an iconic object in the HALCON database.
		///   Instance represents: Objects to be copied.
		/// </summary>
		/// <param name="index">Starting index of the objects to be copied. Default: 1</param>
		/// <param name="numObj">Number of objects to be copied or -1. Default: 1</param>
		/// <returns>Copied objects.</returns>
		// Token: 0x06001C95 RID: 7317 RVA: 0x000B1064 File Offset: 0x000AF264
		public new HXLDExtPara CopyObj(int index, int numObj)
		{
			IntPtr proc = HalconAPI.PreCall(583);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.StoreI(proc, 1, numObj);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Concatenate two iconic object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objects2">Object tuple 2.</param>
		/// <returns>Concatenated objects.</returns>
		// Token: 0x06001C96 RID: 7318 RVA: 0x000B10BC File Offset: 0x000AF2BC
		public HXLDExtPara ConcatObj(HXLDExtPara objects2)
		{
			IntPtr proc = HalconAPI.PreCall(584);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001C97 RID: 7319 RVA: 0x000B1114 File Offset: 0x000AF314
		public new HXLDExtPara SelectObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001C98 RID: 7320 RVA: 0x000B116C File Offset: 0x000AF36C
		public new HXLDExtPara SelectObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001C99 RID: 7321 RVA: 0x000B11BC File Offset: 0x000AF3BC
		public int CompareObj(HXLDExtPara objects2, HTuple epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.Store(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(epsilon);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001C9A RID: 7322 RVA: 0x000B1220 File Offset: 0x000AF420
		public int CompareObj(HXLDExtPara objects2, double epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.StoreD(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare image objects regarding equality.
		///   Instance represents: Test objects.
		/// </summary>
		/// <param name="objects2">Comparative objects.</param>
		/// <returns>boolean result value.</returns>
		// Token: 0x06001C9B RID: 7323 RVA: 0x000B1280 File Offset: 0x000AF480
		public int TestEqualObj(HXLDExtPara objects2)
		{
			IntPtr proc = HalconAPI.PreCall(591);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x06001C9C RID: 7324 RVA: 0x000B12D8 File Offset: 0x000AF4D8
		public HImage GenGridRectificationMap(HImage image, out HXLDExtPara meshes, int gridSpacing, HTuple rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.Store(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDExtPara.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x06001C9D RID: 7325 RVA: 0x000B1384 File Offset: 0x000AF584
		public HImage GenGridRectificationMap(HImage image, out HXLDExtPara meshes, int gridSpacing, string rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.StoreS(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDExtPara.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Choose all contours or polygons containing a given point.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Line coordinate of the test point. Default: 100.0</param>
		/// <param name="column">Column coordinate of the test point. Default: 100.0</param>
		/// <returns>All contours or polygons containing the test point.</returns>
		// Token: 0x06001C9E RID: 7326 RVA: 0x000B1428 File Offset: 0x000AF628
		public new HXLDExtPara SelectXldPoint(HTuple row, HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1676);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Choose all contours or polygons containing a given point.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Line coordinate of the test point. Default: 100.0</param>
		/// <param name="column">Column coordinate of the test point. Default: 100.0</param>
		/// <returns>All contours or polygons containing the test point.</returns>
		// Token: 0x06001C9F RID: 7327 RVA: 0x000B148C File Offset: 0x000AF68C
		public new HXLDExtPara SelectXldPoint(double row, double column)
		{
			IntPtr proc = HalconAPI.PreCall(1676);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select contours or polygons using shape features.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Operation type between the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Contours or polygons fulfilling the condition(s).</returns>
		// Token: 0x06001CA0 RID: 7328 RVA: 0x000B14E4 File Offset: 0x000AF6E4
		public new HXLDExtPara SelectShapeXld(HTuple features, string operation, HTuple min, HTuple max)
		{
			IntPtr proc = HalconAPI.PreCall(1678);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.Store(proc, 2, min);
			HalconAPI.Store(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select contours or polygons using shape features.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Operation type between the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Contours or polygons fulfilling the condition(s).</returns>
		// Token: 0x06001CA1 RID: 7329 RVA: 0x000B1560 File Offset: 0x000AF760
		public new HXLDExtPara SelectShapeXld(string features, string operation, double min, double max)
		{
			IntPtr proc = HalconAPI.PreCall(1678);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.StoreD(proc, 2, min);
			HalconAPI.StoreD(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform the shape of contours or polygons.
		///   Instance represents: Contours or polygons to be transformed.
		/// </summary>
		/// <param name="type">Type of transformation. Default: "convex"</param>
		/// <returns>Transformed contours respectively polygons.</returns>
		// Token: 0x06001CA2 RID: 7330 RVA: 0x000B15CC File Offset: 0x000AF7CC
		public new HXLDExtPara ShapeTransXld(string type)
		{
			IntPtr proc = HalconAPI.PreCall(1689);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Insert objects into an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="objectsInsert">Object tuple to insert.</param>
		/// <param name="index">Index to insert objects.</param>
		/// <returns>Extended object tuple.</returns>
		// Token: 0x06001CA3 RID: 7331 RVA: 0x000B161C File Offset: 0x000AF81C
		public HXLDExtPara InsertObj(HXLDExtPara objectsInsert, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2121);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsInsert);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsInsert);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001CA4 RID: 7332 RVA: 0x000B167C File Offset: 0x000AF87C
		public new HXLDExtPara RemoveObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001CA5 RID: 7333 RVA: 0x000B16D4 File Offset: 0x000AF8D4
		public new HXLDExtPara RemoveObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001CA6 RID: 7334 RVA: 0x000B1724 File Offset: 0x000AF924
		public HXLDExtPara ReplaceObj(HXLDExtPara objectsReplace, HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001CA7 RID: 7335 RVA: 0x000B1788 File Offset: 0x000AF988
		public HXLDExtPara ReplaceObj(HXLDExtPara objectsReplace, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDExtPara result;
			num = HXLDExtPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}
	}
}
